{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import mindspore.dataset as ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_path = '../datasets/MNIST_Data/train'\n",
    "test_data_path = '../dataset/MNIST_Data/test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset.vision.c_transforms as CV\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "from mindspore.dataset.vision import Inter\n",
    "from mindspore import dtype as mstype\n",
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import Normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(data_path, batch_size=32, repeat_size=1,\n",
    "                   num_parallel_workers=8):\n",
    "    \"\"\"\n",
    "    create dataset for train or test\n",
    "\n",
    "    Args:\n",
    "        data_path (str): Data path\n",
    "        batch_size (int): The number of data records in each group\n",
    "        repeat_size (int): The number of replicated data records\n",
    "        num_parallel_workers (int): The number of parallel workers\n",
    "    \"\"\"\n",
    "    # define dataset\n",
    "    mnist_ds = ds.MnistDataset(data_path)\n",
    "\n",
    "    # define some parameters needed for data enhancement and rough justification\n",
    "    resize_height, resize_width = 32, 32\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "    rescale_nml = 1 / 0.3081\n",
    "    shift_nml = -1 * 0.1307 / 0.3081\n",
    "\n",
    "    # according to the parameters, generate the corresponding data enhancement method\n",
    "    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n",
    "    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    hwc2chw_op = CV.HWC2CHW()\n",
    "    type_cast_op = C.TypeCast(mstype.int32)\n",
    "\n",
    "    # using map to apply operations to a dataset\n",
    "    mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "\n",
    "    # process the generated dataset\n",
    "    buffer_size = 10000\n",
    "    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n",
    "    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n",
    "    mnist_ds = mnist_ds.repeat(repeat_size)\n",
    "\n",
    "    return mnist_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms_dataset = create_dataset(train_data_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor of image: (32, 1, 32, 32)\n",
      "Labels: [4 0 4 5 3 3 0 1 6 2 5 6 2 9 1 1 7 7 8 2 7 9 1 6 8 6 4 8 8 8 1 9]\n"
     ]
    }
   ],
   "source": [
    "data = next(ms_dataset.create_dict_iterator(output_numpy=True))\n",
    "images = data[\"image\"]\n",
    "labels = data[\"label\"]\n",
    "print('Tensor of image:', images.shape)\n",
    "print('Labels:', labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LeNet5(nn.Cell):\n",
    "    \"\"\"Lenet network structure.\"\"\"\n",
    "    # define the operator required\n",
    "    def __init__(self, num_class=10, num_channel=1):\n",
    "        super(LeNet5, self).__init__()\n",
    "        # 卷积核大小5*5，卷积核种类6，输入通道为1\n",
    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
    "        self.max_pool2d1 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
    "        self.max_pool2d2 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(400, 120, weight_init=Normal(0.02))\n",
    "        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n",
    "        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    # use the preceding operators to construct networks\n",
    "    def construct(self, x):\n",
    "        x = self.max_pool2d1(self.relu(self.conv1(x)))\n",
    "        x = self.max_pool2d2(self.relu(self.conv2(x)))\n",
    "        x = self.flatten(x)\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "network = LeNet5()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore.train.callback import Callback\n",
    "\n",
    "class StepLossAccInfo(Callback):\n",
    "    def __init__(self, model, eval_dataset, steps_loss, steps_eval):\n",
    "        self.model = model\n",
    "        self.eval_dataset = eval_dataset\n",
    "        self.steps_loss = steps_loss\n",
    "        self.steps_eval = steps_eval\n",
    "        \n",
    "    def step_end(self, run_context):\n",
    "        cb_params = run_context.original_args()\n",
    "        cur_epoch = cb_params.cur_epoch_num\n",
    "        cur_step = (cur_epoch-1)*1875 + cb_params.cur_step_num\n",
    "        self.steps_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n",
    "        self.steps_loss[\"step\"].append(str(cur_step))\n",
    "        if cur_step % 125 == 0:\n",
    "            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n",
    "            self.steps_eval[\"step\"].append(cur_step)\n",
    "            self.steps_eval[\"acc\"].append(acc[\"Accuracy\"])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from mindspore import Tensor, Model\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n",
    "from mindspore.nn import Accuracy\n",
    "import mindspore.nn as nn\n",
    "from mindspore.nn import SoftmaxCrossEntropyWithLogits\n",
    "from mindspore import context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='CPU')\n",
    "lr = 0.01\n",
    "momentum = 0.9\n",
    "\n",
    "# create the network\n",
    "network = LeNet5()\n",
    "# define the optimizer\n",
    "# net_opt = nn.Adam(network.trainable_params())\n",
    "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n",
    "\n",
    "# define the loss function\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "epoch_size = 1\n",
    "mnist_path = \"../datasets/MNIST_Data\"\n",
    "model_path = \"./models/lenet/\"\n",
    "\n",
    "repeat_size = 1\n",
    "ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n",
    "eval_dataset = create_dataset(os.path.join(mnist_path, \"test\"), 32)\n",
    "\n",
    "# clean up old run files before in Linux\n",
    "os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))\n",
    "\n",
    "# define the model\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1 step: 125, loss is 2.3081036\n",
      "epoch: 1 step: 250, loss is 2.2862532\n",
      "epoch: 1 step: 375, loss is 2.295327\n",
      "epoch: 1 step: 500, loss is 2.2856777\n",
      "epoch: 1 step: 625, loss is 2.3160903\n",
      "epoch: 1 step: 750, loss is 2.2850957\n",
      "epoch: 1 step: 875, loss is 2.3201666\n",
      "epoch: 1 step: 1000, loss is 0.7075813\n",
      "epoch: 1 step: 1125, loss is 0.5959907\n",
      "epoch: 1 step: 1250, loss is 0.23731449\n",
      "epoch: 1 step: 1375, loss is 0.26565456\n",
      "epoch: 1 step: 1500, loss is 0.17517422\n",
      "epoch: 1 step: 1625, loss is 0.299496\n",
      "epoch: 1 step: 1750, loss is 0.024585718\n",
      "epoch: 1 step: 1875, loss is 0.17125703\n",
      "epoch: 2 step: 125, loss is 0.11809586\n",
      "epoch: 2 step: 250, loss is 0.047309447\n",
      "epoch: 2 step: 375, loss is 0.014269128\n",
      "epoch: 2 step: 500, loss is 0.09851865\n",
      "epoch: 2 step: 625, loss is 0.041767996\n",
      "epoch: 2 step: 750, loss is 0.049731705\n",
      "epoch: 2 step: 875, loss is 0.115232795\n",
      "epoch: 2 step: 1000, loss is 0.109876804\n",
      "epoch: 2 step: 1125, loss is 0.031761877\n",
      "epoch: 2 step: 1250, loss is 0.0075117103\n",
      "epoch: 2 step: 1375, loss is 0.013591048\n",
      "epoch: 2 step: 1500, loss is 0.030217158\n",
      "epoch: 2 step: 1625, loss is 0.06412532\n",
      "epoch: 2 step: 1750, loss is 0.007894291\n",
      "epoch: 2 step: 1875, loss is 0.008877255\n",
      "epoch: 3 step: 125, loss is 0.29581228\n",
      "epoch: 3 step: 250, loss is 0.08421001\n",
      "epoch: 3 step: 375, loss is 0.0022359907\n",
      "epoch: 3 step: 500, loss is 0.14058624\n",
      "epoch: 3 step: 625, loss is 0.06464292\n",
      "epoch: 3 step: 750, loss is 0.050966255\n",
      "epoch: 3 step: 875, loss is 0.003283576\n",
      "epoch: 3 step: 1000, loss is 0.11848585\n",
      "epoch: 3 step: 1125, loss is 0.035597224\n",
      "epoch: 3 step: 1250, loss is 0.056464113\n",
      "epoch: 3 step: 1375, loss is 0.21061234\n",
      "epoch: 3 step: 1500, loss is 0.047847405\n",
      "epoch: 3 step: 1625, loss is 0.03146019\n",
      "epoch: 3 step: 1750, loss is 0.08977585\n",
      "epoch: 3 step: 1875, loss is 0.07656989\n",
      "epoch: 4 step: 125, loss is 0.006778006\n",
      "epoch: 4 step: 250, loss is 0.10339911\n",
      "epoch: 4 step: 375, loss is 0.0109065\n",
      "epoch: 4 step: 500, loss is 0.33718643\n",
      "epoch: 4 step: 625, loss is 0.025020787\n",
      "epoch: 4 step: 750, loss is 0.096578345\n",
      "epoch: 4 step: 875, loss is 0.005642332\n",
      "epoch: 4 step: 1000, loss is 0.0029155882\n",
      "epoch: 4 step: 1125, loss is 0.09979\n",
      "epoch: 4 step: 1250, loss is 0.1350897\n",
      "epoch: 4 step: 1375, loss is 0.028854378\n",
      "epoch: 4 step: 1500, loss is 0.0011959556\n",
      "epoch: 4 step: 1625, loss is 0.012746576\n",
      "epoch: 4 step: 1750, loss is 0.0051864716\n",
      "epoch: 4 step: 1875, loss is 0.1516218\n",
      "epoch: 5 step: 125, loss is 0.16674203\n",
      "epoch: 5 step: 250, loss is 0.004783524\n",
      "epoch: 5 step: 375, loss is 0.007019765\n",
      "epoch: 5 step: 500, loss is 0.09520198\n",
      "epoch: 5 step: 625, loss is 0.020969167\n",
      "epoch: 5 step: 750, loss is 0.0031775704\n",
      "epoch: 5 step: 875, loss is 0.008753059\n",
      "epoch: 5 step: 1000, loss is 0.004086743\n",
      "epoch: 5 step: 1125, loss is 0.05310721\n",
      "epoch: 5 step: 1250, loss is 0.11995046\n",
      "epoch: 5 step: 1375, loss is 0.008280059\n",
      "epoch: 5 step: 1500, loss is 0.009514566\n",
      "epoch: 5 step: 1625, loss is 0.020766456\n",
      "epoch: 5 step: 1750, loss is 0.030191042\n",
      "epoch: 5 step: 1875, loss is 0.0035973766\n"
     ]
    }
   ],
   "source": [
    "# save the network model and parameters for subsequence fine-tuning\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=375, keep_checkpoint_max=5)\n",
    "# group layers into an object with training and evaluation features\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_lenet\", directory=model_path, config=config_ck)\n",
    "\n",
    "steps_loss = {\"step\": [], \"loss_value\": []}\n",
    "steps_eval = {\"step\": [], \"acc\": []}\n",
    "# collect the steps,loss and accuracy information\n",
    "step_loss_acc_info = StepLossAccInfo(model , eval_dataset, steps_loss, steps_eval)\n",
    "\n",
    "model.train(5, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_acc_info], dataset_sink_mode=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./models/lenet/'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "steps = steps_loss[\"step\"]\n",
    "loss_value = steps_loss[\"loss_value\"]\n",
    "steps = list(map(int, steps))\n",
    "loss_value = list(map(float, loss_value))\n",
    "plt.plot(steps, loss_value, color=\"red\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Loss_value\")\n",
    "plt.title(\"Change chart of model loss value\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Testing ==============\n",
      "============== Accuracy:{'Accuracy': 0.9662459935897436} ==============\n"
     ]
    }
   ],
   "source": [
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "# testing relate modules\n",
    "def test_net(network, model, mnist_path):\n",
    "    \"\"\"Define the evaluation method.\"\"\"\n",
    "    print(\"============== Starting Testing ==============\")\n",
    "    # load the saved model for evaluation\n",
    "    param_dict = load_checkpoint(model_path+\"/checkpoint_lenet-1_1875.ckpt\")\n",
    "    # load parameter to the network\n",
    "    load_param_into_net(network, param_dict)\n",
    "    # load testing dataset\n",
    "    ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n",
    "    acc = model.eval(ds_eval, dataset_sink_mode=False)\n",
    "    print(\"============== Accuracy:{} ==============\".format(acc))\n",
    "\n",
    "test_net(network, model, mnist_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def eval_show(steps_eval):\n",
    "    plt.xlabel(\"step number\")\n",
    "    plt.ylabel(\"Model accuracy\")\n",
    "    plt.title(\"Model accuracy variation chart\")\n",
    "    plt.plot(steps_eval[\"step\"], steps_eval[\"acc\"], \"red\")\n",
    "    plt.show()\n",
    "\n",
    "eval_show(steps_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-54a1794a433f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"label\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0moutput\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'image'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0mpred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0merr_num\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "output = model.predict(Tensor(data['image']))\n",
    "pred = np.argmax(output.asnumpy(), axis=1)\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from net.LeNet import LeNet5, LeNet5_padding\n",
    "from net.utils import *\n",
    "from dataset.preprocess import *\n",
    "from pipecoco.common import *\n",
    "\n",
    "from mindspore.nn import SoftmaxCrossEntropyWithLogits\n",
    "from mindspore.nn import Accuracy\n",
    "from pipecoco.PipeCoCo import PipeCoCo\n",
    "from mindspore import context\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='CPU')\n",
    "\n",
    "mnist_path = \"../datasets/MNIST_Data\"\n",
    "model_path = \"./models/lenet_padding/\"\n",
    "network = LeNet5_padding()\n",
    "\n",
    "# model_path = \"./models/lenet/\"\n",
    "# network = LeNet5()\n",
    "\n",
    "load_model(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\")\n",
    "\n",
    "\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "\n",
    "ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n",
    "# eval(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\", net_loss, ds_eval)\n",
    "\n",
    "layers_list = []\n",
    "dfs_search_layers(network, layers_list)\n",
    "pipecoco_model = PipeCoCo(layers_list, [1 ,32, 32])\n",
    "\n",
    "ds_test = ds_eval.create_dict_iterator()\n",
    "data = next(ds_test)\n",
    "input = data[\"image\"].asnumpy()\n",
    "x = pipecoco_model.forward(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 4 9 2 3 6 4 6 6 9 6 6 7 9 5 2 3 6 4 9 6 9 6 1 8 8 0 9 1 9 8 7]\n",
      "Row 1, column 6 is incorrectly identified as 6, the correct value should be 1 \n",
      "\n",
      "Row 3, column 2 is incorrectly identified as 6, the correct value should be 1 \n",
      "\n",
      "Row 3, column 4 is incorrectly identified as 9, the correct value should be 0 \n",
      "\n",
      "Row 3, column 5 is incorrectly identified as 6, the correct value should be 0 \n",
      "\n",
      "Row 4, column 2 is incorrectly identified as 8, the correct value should be 9 \n",
      "\n",
      "[7 4 9 2 3 6 4 6 6 9 6 6 7 9 5 2 3 6 4 9 6 9 6 1 8 8 0 9 1 9 8 7] <--Predicted figures\n",
      "[7 4 9 2 3 1 4 6 6 9 6 6 7 9 5 2 3 1 4 0 0 9 6 1 8 9 0 9 1 9 8 7] <--The right number\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import mindspore.dataset as ds\n",
    "\n",
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "pred = np.argmax(x.asnumpy(), axis=1)\n",
    "print(pred)\n",
    "\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from net.LeNet import LeNet5, LeNet5_padding\n",
    "from net.utils import *\n",
    "from dataset.preprocess import *\n",
    "from pipecoco.common import *\n",
    "\n",
    "from mindspore.nn import SoftmaxCrossEntropyWithLogits\n",
    "from mindspore.nn import Accuracy\n",
    "from pipecoco.PipeCoCo import PipeCoCo\n",
    "from mindspore import context\n",
    "\n",
    "mnist_path = \"../datasets/MNIST_Data\"\n",
    "model_path = \"./models/lenet_padding/\"\n",
    "network = LeNet5_padding()\n",
    "\n",
    "# model_path = \"./models/lenet/\"\n",
    "# network = LeNet5()\n",
    "\n",
    "load_model(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\")\n",
    "\n",
    "\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "\n",
    "ds_eval = create_dataset(os.path.join(mnist_path, \"test\"),batch_size=32)\n",
    "# eval(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\", net_loss, ds_eval)\n",
    "\n",
    "layers_list = []\n",
    "dfs_search_layers(network, layers_list)\n",
    "pipecoco_model = PipeCoCo(layers_list, [1 ,32, 32], 2, [0,4], 'local')\n",
    "\n",
    "ds_test = ds_eval.create_dict_iterator()\n",
    "data = next(ds_test)\n",
    "input = data[\"image\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 4 9 2 3 6 4 6 6 9 6 6 7 9 5 2 3 6 4 9 6 9 6 1 8 8 0 9 1 9 8 7]\n"
     ]
    }
   ],
   "source": [
    "session_id, init_area_map = pipecoco_model.create_session(input.shape[0])\n",
    "for i in range(4):\n",
    "    area = init_area_map[i]\n",
    "    x = input[:,:,area[0][0]:area[0][1],area[1][0]:area[1][1]]\n",
    "    pipecoco_model.fused_layers_forward(x,i)\n",
    "\n",
    "x = pipecoco_model.non_fused_layers_forward()\n",
    "pred = np.argmax(x.asnumpy(), axis=1)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'plt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-433cc0ce2c16>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mindex\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m8\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m     \u001b[0mcolor\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'blue'\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mpred\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32melse\u001b[0m \u001b[1;34m'red'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"pre:{}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcolor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'plt' is not defined"
     ]
    }
   ],
   "source": [
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tensor(shape=[32, 10], dtype=Float32, value=\n",
       "[[0.00000000e+000, 0.00000000e+000, 0.00000000e+000 ... 0.00000000e+000, 7.49511528e+000, 0.00000000e+000],\n",
       " [0.00000000e+000, 2.90387573e+001, 5.39811821e+001 ... 3.87149000e+000, 0.00000000e+000, 0.00000000e+000],\n",
       " [0.00000000e+000, 1.70191727e+001, 1.01808529e+001 ... 4.39658880e+000, 1.38583784e+001, 0.00000000e+000],\n",
       " ...\n",
       " [0.00000000e+000, 1.47295761e+001, 1.14720201e+001 ... 2.98656883e+001, 4.28096104e+000, 1.04009237e+001],\n",
       " [0.00000000e+000, 1.43146973e+001, 0.00000000e+000 ... 0.00000000e+000, 1.09088335e+001, 0.00000000e+000],\n",
       " [0.00000000e+000, 7.50243092e+000, 1.30722437e+001 ... 2.42367178e-001, 0.00000000e+000, 0.00000000e+000]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tensor(shape=[32, 10], dtype=Float32, value=\n",
       "[[-2.82714224e+000, -4.63068676e+000, -5.20965958e+000 ... -4.85289288e+000, 2.21676278e+000, 1.57282662e+000],\n",
       " [-7.12618768e-001, -2.66876161e-001, 1.74295082e+001 ... 2.89927197e+000, -1.29472339e+000, -5.54239321e+000],\n",
       " [-4.68004656e+000, -4.31437612e-001, 3.99178386e-001 ... 6.85943317e+000, 9.44625378e-001, 2.36827135e+000],\n",
       " ...\n",
       " [-5.11309719e+000, -1.19877470e+000, 8.93071443e-002 ... 1.32827244e+001, -1.31494629e+000, 2.72616100e+000],\n",
       " [-5.71175003e+000, 1.28954124e+001, -8.19462478e-001 ... -2.99379563e+000, 2.81690836e+000, 5.97180068e-001],\n",
       " [-4.79161310e+000, 1.08025646e+000, 2.70344806e+000 ... 5.35382628e-001, -1.64737940e+000, 6.30253315e-001]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_model(network, model_path + \"/checkpoint_lenet-5_1875.ckpt\")\n",
    "model = Model(network, net_loss, metrics={\"Accuracy\": Accuracy()})\n",
    "pred = np.argmax(model.predict(input), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row 4, column 8 is incorrectly identified as 9, the correct value should be 7 \n",
      "\n",
      "[7 4 9 2 3 1 4 6 6 9 6 6 7 9 5 2 3 1 4 0 0 9 6 1 8 9 0 9 1 9 8 9] <--Predicted figures\n",
      "[7 4 9 2 3 1 4 6 6 9 6 6 7 9 5 2 3 1 4 0 0 9 6 1 8 9 0 9 1 9 8 7] <--The right number\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [[1,2],[2,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'array' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-49f58104c70a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'array' is not defined"
     ]
    }
   ],
   "source": [
    "array(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mindspore",
   "language": "python",
   "name": "mindspore"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
